package com.douma.第14天;

import java.util.LinkedList;
import java.util.Scanner;

/**
 * 抖码算法，让算法学习变的简单有趣
 *
 * @作者 : 老汤
 */
public class 数字反转打印 {
    /*
    题目 3：数字反转打印

小华是个很有对数字很敏感的小朋友，他觉得数字的不同排列方式有特殊美感。

某天，小华突发奇想，如果数字多行排列，第一行 1 个数，第二行 2 个，第三行 3 个，即第 n 行有 n 个数字，并且奇数行正序排列，偶数行逆序排列，数字依次累加。

这样排列的数字一定很有意思。聪明的你能编写代码帮助小华完成这个想法吗？

规则总结如下：
a、每个数字占据 4 个位置，不足四位用 * 补位，如 1 打印为 1***
b、数字之间相邻 4 空格
c、数字的打印顺序按照正序逆序交替打印，奇数行正序，偶数行逆序
d、最后一行数字顶格，第 n - 1 行相对第 n 行缩进四个空格

输入描述：
第一行输入为 N，表示打印多少行，1 <= N <= 30
输入：2

输出描述：
XXXX1***
3***XXXX2***

说明：符号 * 表示，数字不满 4 位时的补位，符号 X 表示数字之间的空格。注意实际编码时不需要打印 X，直接打印空格即可。此处为说明题意，故此加上 X

示例 1：
输入
2

输出
    1***
3***    2***

示例 2：
输入
3

输出
        1***
    3***    2***
4***    5***    6****


示例 3：
输入
4

输出
            1***
        3***    2***
    4***    5***    6****
10**    9***    8***    7***
     */
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        int n = sc.nextInt();

        if (n <= 0) {
            System.exit(0);
        }

        LinkedList<String>[] res = new LinkedList[n];
        // 初始化第 1 行的 1
        res[0] = new LinkedList<>();
        res[0].add(padRight(1, 4));

        // 初始化上一行的第一个数字为 1
        int lastLineFirstNum = 1;
        for (int i = 1; i < n; i++) {
            res[i] = new LinkedList<>();

            // 前 i 行的前面拼接 4 个空格
            for (int line = 0; line < i; line++) {
                res[line].addFirst("    ");
            }

            // 判断是否是奇数，注意 i 是索引，索引从 0 开始，所以需要 +1
            boolean isOdd = ((i + 1) % 2 == 1);
            // 当前这一行的第一个数字等于上一行的第一个数字再加上索引 i
            /*
                        1***                    第一行的第一个数字是 1
                    3***    2***                第二行的第一个数字是 2
                4***    5***    6****           第三行的第一个数字是 4
            10**    9***    8***    7***        第四行的第一个数字是 7
             */
            int firstNum = lastLineFirstNum + i;
            if (isOdd) {
                // 如果是奇数行的话，则正序排列
                for (int j = 0; j <= i; j++) {
                    // 除了第一个，都需要拼接 4 个空格
                    if (j > 0) {
                        res[i].addLast("    ");
                    }
                    res[i].addLast(padRight(firstNum + j, 4));
                }
            } else {
                // 如果是偶数行的话，则逆序排列
                for (int j = 0; j <= i; j++) {
                    // 除了第一个，都需要拼接 4 个空格
                    if (j > 0) {
                        res[i].addFirst("    ");
                    }
                    res[i].addFirst(padRight(firstNum + j, 4));
                }
            }

            // 循环结束后，当前这一行就变成了前一行了，所以这里更新下前一行的第一个数字
            lastLineFirstNum = firstNum;
        }

        // 打印结果
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < res[i].size(); j++) {
                System.out.print(res[i].get(j));
            }
            System.out.println();
        }

        sc.close();
    }

    // 如果数字 num 的长度小于 n，则在 num 的后面拼接 *，直到长度为 n 为止
    public static String padRight(int num, int n) {
        StringBuilder tmp = new StringBuilder(num + "");
        while (tmp.length() < n) {
            tmp.append("*");
        }
        return tmp.toString();
    }
}
